// 一个有名的按摩师会收到源源不断的预约请求，每个预约都可以选择接或不接。
// 在每次预约服务之间要有休息时间，因此她不能接受相邻的预约。
// 给定一个预约请求序列，替按摩师找到最优的预约集合（总预约时间最长），返回总的分钟数。

// 输入： [1,2,3,1]
// 输出： 4
// 解释： 选择 1 号预约和 3 号预约，总时长 = 1 + 3 = 4。

// 输入： [2,7,9,3,1]
// 输出： 12
// 解释： 选择 1 号预约、 3 号预约和 5 号预约，总时长 = 2 + 9 + 1 = 12。

// 输入： [2,1,4,5,3,1,1,3]
// 输出： 12
// 解释： 选择 1 号预约、 3 号预约、 5 号预约和 8 号预约，总时长 = 2 + 4 + 3 + 3 = 12。


// [2,1,4,15,23,1,1,3]



/**
 * @param {number[]} nums
 * @return {number}
 */
// var massage = function (nums) {
//   var i = -2
//   var sum = 0
//   if (nums.length == 1) {
//     return nums[0]
//   }
//   while (i <= nums.length && (i + 2) < nums.length) {
//     var nums1 = nums[i + 2] || 0
//     var nums2 = nums[i + 3] || 0
//     var nums3 = nums[i + 4] || 0
//     var nums4 = nums[i + 5] || 0
//     if ((nums1 + nums3) >= (nums2 + nums4)) {
//       i += 2
//     } else if ((nums1 + nums4) > (nums2 + nums3)) {
//       i += 2
//     } else if ((nums2 + nums4) >= (nums1 + nums3)){
//       i += 3
//     }

//     sum += nums[i]
//   }
//   return sum
// };

// var testArr = [1, 2, 3]
// console.log(testArr[4] + 1)

// console.log(massage([2,1,4,5,3,1,1,3]))
// console.log(massage([2,7,9,3,1]))
// console.log(massage([1, 2, 3, 1]))

// console.log(massage([1, 2, 1, 2]))
// console.log(massage([2,4,8,9,9,3]))

// console.log(massage([0]))


// 这种算法不行呀 局部最优解 不行啊


// 二叉树
// 二叉树 怎么生成?



var massage1 = function (nums) {
  [...nums].reduce((dp, num) => {
    console.log(dp)
    return [Math.max(...dp), dp[0] + num]
  }, [0, 0])
  // return Math.max(...nums.reduce((dp, num) => [Math.max(...dp), dp[0] + num], [0, 0]))
};

// console.log(massage([1, 2, 1, 0]))

var massage = function (nums) {
  let dp = new Array(nums.length);
  if (nums.length == 0) {
      return 0;
  }
  if (nums.length == 1) {
      return nums[0];
  }
  dp[0] = nums[0];
  dp[1] = Math.max(nums[0], nums[1]);
  for (let i = 2; i < nums.length; i++) {
      dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
  }
  console.log(dp)
  return dp[nums.length - 1];
};

console.log(massage([4, 1, 2, 7, 5, 3, 1]))
